home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / win / vb / inpgrid.exe / API.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-06  |  21.7 KB  |  649 lines
  1. //--------------------------------------------------------------------------
  2. // Api.c
  3. //---------------------------------------------------------------------------
  4. // Griglia Control
  5. //---------------------------------------------------------------------------
  6.  
  7. #define NOCOMM
  8.  
  9. #include <windows.h>
  10. #include <string.h>
  11.  
  12. #include "vbapi.h"
  13. #include "griglia.h"
  14.  
  15. //---------------------------------------------------------------------------
  16. // RepaintGriglia
  17. //---------------------------------------------------------------------------
  18. VOID _export RepaintGriglia (HWND hWnd) {
  19.  
  20.     HCTL hctlLocal;    
  21.  
  22.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  23.  
  24.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  25.  
  26.         InvalidateRect (lpGrigliaStruct->hWndStatic, NULL, TRUE);        
  27.  
  28.     }
  29. }
  30.  
  31. //---------------------------------------------------------------------------
  32. // GetGrigliaProperty
  33. //---------------------------------------------------------------------------
  34. BOOL _export GetGrigliaProperty (HWND    hWnd,
  35.                                  USHORT nProp,                                 
  36.                                  LPVOID lpData) {                     
  37.  
  38.     HCTL hctlLocal;
  39.  
  40.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  41.     switch (nProp) {
  42.         case    IPROP_GRIGLIA_ROWS:
  43.         case    IPROP_GRIGLIA_COLS:
  44.         case    IPROP_GRIGLIA_FIXEDROWS:
  45.         case    IPROP_GRIGLIA_FIXEDCOLS:
  46.         case    IPROP_GRIGLIA_ROW:
  47.         case    IPROP_GRIGLIA_COL:
  48.         case    IPROP_GRIGLIA_ROWHEIGHT:
  49.         case    IPROP_GRIGLIA_COLWIDTH:
  50.         case    IPROP_GRIGLIA_TOPROW:
  51.         case    IPROP_GRIGLIA_LEFTCOL:
  52.         case    IPROP_GRIGLIA_CURSORROW:
  53.         case    IPROP_GRIGLIA_CURSORCOL:
  54.         case    IPROP_GRIGLIA_TEXT:
  55.         case    IPROP_GRIGLIA_CLIP:
  56.         case    IPROP_GRIGLIA_SELSTARTROW:
  57.         case    IPROP_GRIGLIA_SELENDROW:
  58.         case    IPROP_GRIGLIA_SELSTARTCOL:
  59.         case    IPROP_GRIGLIA_SELENDCOL:
  60.             return (VBGetControlProperty (hctlLocal, nProp, lpData) == 0);    
  61.         }    
  62.     }
  63.     return (FALSE);    
  64. }
  65.  
  66. //---------------------------------------------------------------------------
  67. // SetGrigliaProperty
  68. //---------------------------------------------------------------------------
  69. BOOL _export SetGrigliaProperty (HWND    hWnd,
  70.                                  USHORT nProp,
  71.                                  LONG   lData) {
  72.  
  73.     HCTL hctlLocal;
  74.  
  75.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  76.         switch (nProp) {
  77.             case    IPROP_GRIGLIA_ROWS:
  78.             case    IPROP_GRIGLIA_COLS:
  79.             case    IPROP_GRIGLIA_FIXEDROWS:
  80.             case    IPROP_GRIGLIA_FIXEDCOLS:
  81.             case    IPROP_GRIGLIA_ROW:
  82.             case    IPROP_GRIGLIA_COL:
  83.             case    IPROP_GRIGLIA_ROWHEIGHT:
  84.             case    IPROP_GRIGLIA_COLWIDTH:
  85.             case    IPROP_GRIGLIA_TOPROW:
  86.             case    IPROP_GRIGLIA_LEFTCOL:
  87.             case    IPROP_GRIGLIA_CURSORROW:
  88.             case    IPROP_GRIGLIA_CURSORCOL:
  89.             case    IPROP_GRIGLIA_TEXT:
  90.             case    IPROP_GRIGLIA_CLIP:
  91.             case    IPROP_GRIGLIA_SELSTARTROW:
  92.             case    IPROP_GRIGLIA_SELENDROW:
  93.             case    IPROP_GRIGLIA_SELSTARTCOL:
  94.             case    IPROP_GRIGLIA_SELENDCOL:
  95.                 return (VBSetControlProperty (hctlLocal, nProp, lData) == 0);                
  96.         }        
  97.     }    
  98.     return (FALSE);    
  99. }
  100.  
  101. //---------------------------------------------------------------------------
  102. // PutText
  103. //---------------------------------------------------------------------------
  104. BOOL _export PutText (HWND    hWnd,
  105.                       WORD    wRow,                        
  106.                       WORD    wCol,        
  107.                       LPSTR   lpText) {            
  108.     HCTL hctlLocal;    
  109.  
  110.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  111.  
  112.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  113.  
  114.         if (        
  115.             (lpText) &&            
  116.             (lstrlen (lpText))            
  117.            )       
  118.             return (PutCellText (lpGrigliaStruct,            
  119.                                 wRow,                                 
  120.                                 wCol,                 
  121.                                 lpText));                 
  122.         return (TRUE);
  123.     }
  124.     return (FALSE);    
  125. }
  126.  
  127. //---------------------------------------------------------------------------
  128. // GetText
  129. //---------------------------------------------------------------------------
  130. LPSTR _export GetText (HWND    hWnd,
  131.                        WORD    wRow,                        
  132.                        WORD    wCol) {
  133.     HCTL hctlLocal;    
  134.  
  135.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  136.  
  137.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  138.  
  139.         return (GetCellText (lpGrigliaStruct,        
  140.                              wRow,                             
  141.                              wCol));             
  142.     }
  143.     return (FALSE);    
  144. }
  145.  
  146. //---------------------------------------------------------------------------
  147. // InsertLines
  148. //---------------------------------------------------------------------------
  149. BOOL _export InsertLines (HWND    hWnd,
  150.                           WORD    wRow,
  151.                           WORD    wInsertRows) {
  152.  
  153.     HCTL hctlLocal;    
  154.  
  155.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  156.  
  157.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  158.  
  159.         return (InsertLinesText (lpGrigliaStruct,        
  160.                                   wRow,                                 
  161.                                   wInsertRows));                 
  162.     }
  163.     return (FALSE);    
  164.  
  165. }
  166.  
  167. //---------------------------------------------------------------------------
  168. // DeleteLines
  169. //---------------------------------------------------------------------------
  170. BOOL _export DeleteLines (HWND    hWnd,
  171.                           WORD    wRow,                        
  172.                           WORD    wDeleteRows) {                
  173.  
  174.     HCTL hctlLocal;    
  175.  
  176.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  177.  
  178.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  179.  
  180.         return (DeleteLinesText (lpGrigliaStruct,        
  181.                                  wRow,                             
  182.                                  wDeleteRows));                 
  183.     }
  184.     return (FALSE);    
  185.  
  186. }
  187.  
  188. //---------------------------------------------------------------------------
  189. // FindLine
  190. //---------------------------------------------------------------------------
  191. BOOL _export FindLine (    HWND         hWnd,
  192.                         LPFINDTEXT      lpFind) {
  193.  
  194.     HCTL hctlLocal;
  195.  
  196.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  197.  
  198.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  199.  
  200.         return (FindText (lpGrigliaStruct,        
  201.                           lpFind));      
  202.     }
  203.     return (0xffff);    
  204.  
  205. }
  206.  
  207. //---------------------------------------------------------------------------
  208. // EraseLines
  209. //---------------------------------------------------------------------------
  210. void _export EraseGrid (HWND hWnd) {
  211.  
  212.     HCTL hctlLocal;    
  213.  
  214.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  215.  
  216.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  217.         
  218.         ClearText (lpGrigliaStruct);
  219.     }
  220. }
  221.  
  222. //---------------------------------------------------------------------------
  223. // SelColSize in CHARS
  224. //---------------------------------------------------------------------------
  225. void _export SetColSize (HWND hWnd,
  226.                          UINT nCol,
  227.                          UINT nColSize) {
  228.  
  229.     UINT nColSizeTwips;
  230.  
  231.     if (SetGrigliaProperty (hWnd,
  232.                             IPROP_GRIGLIA_COL,
  233.                             MAKELONG (nCol, 0))) {     
  234.         
  235.         nColSizeTwips = (WORD)VBYPixelsToTwips (nColSize);
  236.         SetGrigliaProperty (hWnd,
  237.                             IPROP_GRIGLIA_COLWIDTH,
  238.                             MAKELONG (nColSizeTwips, 0));
  239.     
  240.     }                        
  241. }
  242.  
  243. //---------------------------------------------------------------------------
  244. // SortLine
  245. //---------------------------------------------------------------------------
  246. BOOL _export SortLine ( HWND            hWnd,
  247.                         LPFINDTEXT      lpFind) {
  248.  
  249.     HCTL hctlLocal;
  250.  
  251.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  252.  
  253.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  254.  
  255.         SortText (lpGrigliaStruct,        
  256.                   lpFind);      
  257.         return (TRUE);
  258.     }
  259.     return (0xffff);    
  260.  
  261. }
  262.  
  263. //---------------------------------------------------------------------------
  264. // InsertCells
  265. //---------------------------------------------------------------------------
  266. void _export InsertCells (HWND    hWnd,
  267.                           WORD    wRow,
  268.                           WORD    wCol,
  269.                           WORD    wInsertCells) {
  270.  
  271.     HCTL hctlLocal;    
  272.  
  273.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  274.  
  275.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  276.  
  277.         InsertCellsText (lpGrigliaStruct,        
  278.                          wRow,                                 
  279.                          wCol,                              
  280.                          wInsertCells);
  281.     }
  282. }
  283.  
  284. //---------------------------------------------------------------------------
  285. // InsertLineBreak
  286. //---------------------------------------------------------------------------
  287. void _export InsertLineBreak (HWND    hWnd,
  288.                               WORD    wRow,
  289.                               WORD    wCol) {
  290.  
  291.     HCTL hctlLocal;    
  292.  
  293.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  294.  
  295.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  296.  
  297.         LineBreakText (lpGrigliaStruct,
  298.                        wRow,
  299.                        wCol);
  300.     }
  301. }
  302.  
  303. //---------------------------------------------------------------------------
  304. // DeleteCells
  305. //---------------------------------------------------------------------------
  306. void _export DeleteCells (HWND    hWnd,
  307.                           WORD    wRow,
  308.                           WORD    wCol,
  309.                           WORD    wDeleteCells) {
  310.  
  311.     HCTL hctlLocal;    
  312.  
  313.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  314.  
  315.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  316.  
  317.         DeleteCellsText (lpGrigliaStruct,
  318.                          wRow,                                 
  319.                          wCol,                              
  320.                          wDeleteCells);
  321.     }
  322. }
  323.  
  324. //---------------------------------------------------------------------------
  325. // DeleteLineBreak
  326. //---------------------------------------------------------------------------
  327. void _export DeleteLineBreak (HWND    hWnd,
  328.                               WORD    wRow,
  329.                               WORD    wCol) {
  330.  
  331.     HCTL hctlLocal;    
  332.  
  333.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  334.  
  335.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  336.  
  337.         RemoveLineBreakText (lpGrigliaStruct,
  338.                              wRow,
  339.                              wCol);
  340.     }
  341. }
  342.  
  343. //---------------------------------------------------------------------------
  344. // MoveWordLeft
  345. //---------------------------------------------------------------------------
  346. void FAR PASCAL _export MoveWordLeft (HWND    hWnd,
  347.                                       WORD    wRow,
  348.                                       WORD    wCol) {
  349.  
  350.     HCTL hctlLocal;    
  351.  
  352.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  353.  
  354.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  355.  
  356.         MoveWordTextLeft (lpGrigliaStruct,
  357.                           wRow,
  358.                           wCol);
  359.     }
  360. }
  361.  
  362. //---------------------------------------------------------------------------
  363. // MoveWordRight
  364. //---------------------------------------------------------------------------
  365. void FAR PASCAL _export MoveWordRight (HWND    hWnd,
  366.                                        WORD    wRow,
  367.                                        WORD    wCol) {
  368.  
  369.     HCTL hctlLocal;    
  370.  
  371.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  372.  
  373.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  374.  
  375.         MoveWordTextRight (lpGrigliaStruct,
  376.                            wRow,
  377.                            wCol);
  378.     }
  379. }
  380.  
  381. //---------------------------------------------------------------------------
  382. // ShiftWordLeft
  383. //---------------------------------------------------------------------------
  384. void FAR PASCAL _export ShiftWordLeft (HWND    hWnd,
  385.                                        WORD    wRow,
  386.                                        WORD    wCol) {
  387.  
  388.     HCTL hctlLocal;    
  389.  
  390.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  391.  
  392.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  393.  
  394.         ShiftWordTextLeft (lpGrigliaStruct,
  395.                            wRow,
  396.                            wCol);
  397.     }
  398. }
  399.  
  400. //---------------------------------------------------------------------------
  401. // ShiftWordRight
  402. //---------------------------------------------------------------------------
  403. void FAR PASCAL _export ShiftWordRight (HWND    hWnd,
  404.                                         WORD    wRow,
  405.                                         WORD    wCol) {
  406.  
  407.     HCTL hctlLocal;    
  408.  
  409.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  410.  
  411.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  412.  
  413.         ShiftWordTextRight (lpGrigliaStruct,
  414.                             wRow,
  415.                             wCol);
  416.     }
  417. }
  418.  
  419. //----------------------------------------------------------------------------
  420. // ADJUST COLUMN SIZES
  421. //----------------------------------------------------------------------------
  422. void FAR PASCAL _export AdjustColumnSizes (HWND hWnd) {
  423.                                     
  424.     static ULONG    lRows;    
  425.     static ULONG    lCols;    
  426.     static ULONG    lFixedRows;    
  427.     static ULONG    lFixedCols;    
  428.     LPSTR  lpText;    
  429.     UINT   n, m, nLength, xChar;                                
  430.     HDC    hDC;
  431.     HCTL   hctlLocal;    
  432.     
  433.     // Get # of rows and cols    
  434.     GetGrigliaProperty (hWnd,    
  435.                         (USHORT)IPROP_GRIGLIA_ROWS,
  436.                         (LPVOID)&lRows);
  437.     GetGrigliaProperty (hWnd,    
  438.                         (USHORT)IPROP_GRIGLIA_COLS,
  439.                         (LPVOID)&lCols);
  440.     GetGrigliaProperty (hWnd,    
  441.                         (USHORT)IPROP_GRIGLIA_FIXEDROWS,
  442.                         (LPVOID)&lFixedRows);
  443.     GetGrigliaProperty (hWnd,    
  444.                         (USHORT)IPROP_GRIGLIA_FIXEDCOLS,
  445.                         (LPVOID)&lFixedCols);
  446.  
  447.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  448.  
  449.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  450.  
  451.         if (hDC = GetDC (hWnd)) {
  452.             static TEXTMETRIC  sTextMetrics;                
  453.             HFONT  hOldFont;
  454.         
  455.             hOldFont = SelectObject (hDC, lpGrigliaStruct->hFont);
  456.             GetTextMetrics (hDC, (LPTEXTMETRIC) &sTextMetrics);            
  457.             xChar = (sTextMetrics.tmAveCharWidth + 
  458.                      sTextMetrics.tmMaxCharWidth) / 2;
  459.             if (hOldFont)
  460.                 SelectObject (hDC, hOldFont);
  461.             ReleaseDC (hWnd, hDC);            
  462.         
  463.             for (n = LOWORD (lFixedCols); n < LOWORD (lCols); ++n) {
  464.                 nLength = 0;
  465.                 if (lpText = GetText (hWnd, 0, n))    
  466.                     nLength = max (nLength, _fstrlen (lpText));       
  467.                 for (m = LOWORD (lFixedRows); m < LOWORD (lRows); ++m) {
  468.                     if (lpText = GetText (hWnd, m, n))
  469.                         nLength = max (nLength, _fstrlen (lpText));   
  470.                 }    
  471.                 SetColSize (hWnd, n, (UINT) (xChar * nLength + 5));
  472.             }          
  473.         }    
  474.     }        
  475. } 
  476.  
  477. //----------------------------------------------------------------------------
  478. // GetBlockSize
  479. //----------------------------------------------------------------------------
  480. UINT FAR PASCAL _export GetBlockSize (HWND hWnd,
  481.                                       WORD wTop,
  482.                                       WORD wLeft,
  483.                                       WORD wBottom,
  484.                                       WORD wRight) {
  485.                                     
  486.     LPSTR  lpText;    
  487.     UINT   n, m, nLength, nTotLength;                                
  488.     
  489.     nTotLength = 0;
  490.     for (n = wLeft; n <= wRight; ++n) {
  491.         nLength = 0;    
  492.         for (m = wTop; m <= wBottom; ++m) {
  493.             if (lpText = GetText (hWnd, m, n)) {
  494.                 nLength = max (nLength, _fstrlen (lpText));
  495.             }
  496.         }          
  497.         nTotLength += nLength;
  498.         if (n != wRight)
  499.             ++nTotLength;    
  500.     }                 
  501.     
  502.     return (nTotLength);       
  503. } 
  504.  
  505. //----------------------------------------------------------------------------
  506. // CJust            
  507. //----------------------------------------------------------------------------
  508. void FAR PASCAL _export CJust (HWND hWnd,
  509.                                WORD wTop,
  510.                                WORD wLeft,
  511.                                WORD wBottom,
  512.                                WORD wRight) {
  513.  
  514.     HCTL hctlLocal;    
  515.  
  516.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  517.  
  518.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  519.  
  520.         Just (lpGrigliaStruct, wTop, wLeft, wBottom, wRight, CENTER_JUST);
  521.     }
  522. }
  523.  
  524. //----------------------------------------------------------------------------
  525. // LJust            
  526. //----------------------------------------------------------------------------
  527. void FAR PASCAL _export LJust (HWND hWnd,
  528.                                WORD wTop,
  529.                                WORD wLeft,
  530.                                WORD wBottom,
  531.                                WORD wRight) {
  532.                                
  533.     HCTL hctlLocal;    
  534.  
  535.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  536.  
  537.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  538.  
  539.         Just (lpGrigliaStruct, wTop, wLeft, wBottom, wRight, LEFT_JUST);
  540.     }
  541. }
  542.  
  543. //----------------------------------------------------------------------------
  544. // RJust            
  545. //----------------------------------------------------------------------------
  546. void FAR PASCAL _export RJust (HWND hWnd,
  547.                                WORD wTop,
  548.                                WORD wLeft,
  549.                                WORD wBottom,
  550.                                WORD wRight) {
  551.                                
  552.     HCTL hctlLocal;    
  553.  
  554.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  555.  
  556.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  557.  
  558.         Just (lpGrigliaStruct, wTop, wLeft, wBottom, wRight, RIGHT_JUST);
  559.     }
  560. }
  561.  
  562. //----------------------------------------------------------------------------
  563. // IsBlockEmpty
  564. //----------------------------------------------------------------------------
  565. BOOL FAR PASCAL _export IsBlockEmpty (HWND hWnd,
  566.                                       WORD wTop,
  567.                                       WORD wLeft,
  568.                                       WORD wBottom,
  569.                                       WORD wRight) {
  570.                                     
  571.     LPSTR  lpText;    
  572.     UINT   n, m;
  573.     
  574.     for (n = wLeft; n <= wRight; ++n) {
  575.         for (m = wTop; m <= wBottom; ++m) {
  576.             if (
  577.                 (lpText = GetText (hWnd, m, n)) &&
  578.                 (_fstrlen (lpText))
  579.                ) {
  580.  
  581.                 // remove initial blanks
  582.                 while (
  583.                        (*lpText)        &&
  584.                        (*lpText == ' ')
  585.                       )
  586.                     ++lpText;
  587.  
  588.                 // anything left ?
  589.                 if (
  590.                     (*lpText) &&
  591.                     (_fstrlen (lpText))
  592.                    )
  593.                     return (FALSE);
  594.             }
  595.         }          
  596.     }                 
  597.     
  598.     return (TRUE);
  599. } 
  600.  
  601. //---------------------------------------------------------------------------
  602. // PutText_Ext
  603. //---------------------------------------------------------------------------
  604. BOOL _export PutText_Ext (HWND        hWnd,
  605.                           WORD        wRow,
  606.                           WORD        wCol,
  607.                           LPEXT_INPUT lpExt,
  608.                           LPSTR       lpText) {
  609.     HCTL hctlLocal;    
  610.  
  611.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  612.  
  613.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  614.  
  615.         if (        
  616.             (lpText) &&            
  617.             (lpExt)  &&
  618.             (_fstrlen (lpText))
  619.            )
  620.             return (PutCellText_Ext (lpGrigliaStruct,
  621.                                      wRow,
  622.                                      wCol,
  623.                                      lpExt,
  624.                                      lpText));
  625.     }
  626.     return (FALSE);    
  627. }
  628.  
  629. //---------------------------------------------------------------------------
  630. // GetText_Ext
  631. //---------------------------------------------------------------------------
  632. LPSTR _export GetText_Ext (HWND        hWnd,
  633.                            WORD        wRow,
  634.                            WORD        wCol,
  635.                            LPEXT_INPUT lpExt) {
  636.     HCTL hctlLocal;    
  637.  
  638.     if (hctlLocal = VBGetHwndControl (hWnd)) {
  639.  
  640.         PGRIGLIA lpGrigliaStruct = GRIGLIADEREF(hctlLocal);        
  641.  
  642.         return (GetCellText_Ext (lpGrigliaStruct,
  643.                                  wRow,
  644.                                  wCol,
  645.                                  lpExt));
  646.     }
  647.     return (FALSE);    
  648. }
  649.